home *** CD-ROM | disk | FTP | other *** search
/ Practical Algorithms for Image Analysis / Practical Algorithms for Image Analysis.iso / TARFILE.GZ / tarfile / ch_3.5 / bcd / edge / det.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-09-11  |  6.5 KB  |  296 lines
  1. /*
  2.  * (c) Copyright 1988 by
  3.  * Robotics Principles Research Department, ATT Bell Laboratories.
  4.  * All rights reserved.
  5.  * Last modified 2/8/88 Ingemar J. Cox
  6.  * C version 8/2/88 Deborah A. Wallach
  7.  * C version 11/4/88 W. J. Kropfl
  8.  */
  9. #include <stdio.h>
  10. #include <math.h>
  11. #include "edge_finder.h"
  12.  
  13. extern struct image *my_image;
  14.  
  15. void
  16. image_detx()
  17. {
  18.     register int *dP, *gP;
  19.     register int ix, iy;
  20.     register int nx, ny, nxM1;
  21.  
  22.     nx = my_image->nx;    nxM1 = nx-1;
  23.     ny = my_image->ny;
  24.     
  25.     if((my_image->idx = (int *)malloc(ny*nx*sizeof(int)))==0)
  26.     {
  27.         fprintf(stderr, "error: cannot allocate idx array\n");
  28.         exit(1);
  29.     }
  30.     
  31.     dP = my_image->idx;
  32.     gP = my_image->gaussian;
  33.     for(iy=0; iy<ny; iy++)
  34.     {
  35. /*        d[iy*nx] = g[iy*nx] - g[iy*nx+1]; */
  36.         *dP = *gP - *(gP+1);
  37.         dP+=nx; gP+=nx;
  38.     }
  39.     for(iy=0; iy<ny; iy++)
  40.     {
  41.         dP = my_image->idx+iy*nx+1;
  42.         gP = my_image->gaussian+iy*nx+2;
  43.         for(ix=1; ix<nxM1; ix++)
  44.         {
  45. /*            d[ix] = g[ix+1] - g[ix-1]; */
  46.             *dP = *gP - *(gP-2);
  47.             dP++; gP++;
  48.         }
  49.     }
  50.     dP = my_image->idx+nx-1;
  51.     gP = my_image->gaussian+nx-1;
  52.     for(iy=0; iy<ny; iy++)
  53.     {
  54. /*        d[iy*nx+nx-1] = g[iy*nx+nx-1] - g[iy*nx+nx-2]; */
  55.         *dP = *gP - *(gP-1);
  56.         dP+=nx; gP+=nx;
  57.     }
  58. #ifdef DEBUG
  59.     image_Write_int("detx", my_image->idx);
  60. #endif
  61. }
  62.  
  63. void
  64. image_dety()
  65. {
  66.     register int *dP, *gP;
  67.     register int ix, iy, nx, ny, nyM1, nxPnx;
  68.  
  69.     nx = my_image->nx;    nxPnx = nx+nx;
  70.     ny = my_image->ny;    nyM1 = ny-1;
  71.     
  72.     if((my_image->idy = (int *)malloc(ny*nx*sizeof(int)))==0)
  73.     {
  74.         fprintf(stderr, "error: cannot allocate idy array\n");
  75.         exit(1);
  76.     }
  77.     
  78.     dP = my_image->idy;
  79.     gP = my_image->gaussian;
  80.     for(ix=0; ix<nx; ix++)
  81.     {
  82.         dP[ix] = gP[ix] - gP[ix+nx]; 
  83. /*        *dP = *gP - *(gP+nx);    */
  84. /*        dP++; gP++;    */
  85.     }
  86.     for(ix=0; ix<nx; ix++)
  87.     {
  88.         dP = my_image->idy+ix;
  89.         gP = my_image->gaussian+ix;
  90.         for(iy=1; iy<nyM1; iy++)
  91.         {
  92.             dP += nx;
  93.             *dP = *(gP+nxPnx)- *gP;
  94.             gP += nx;
  95.         }
  96.     }
  97.     dP = my_image->idy+(ny-1)*nx;
  98.     gP = my_image->gaussian+(ny-1)*nx;
  99.     for(ix=0; ix<nx; ix++)
  100.     {
  101.         dP[ix] = gP[ix] - gP[ix-nx];
  102. /*        *dP = *gP - *(gP-nx);    */
  103. /*        dP++; gP++; */
  104.     }
  105. #ifdef DEBUG
  106.     image_Write_int("dety", my_image->idy);
  107. #endif
  108. }
  109. void
  110. image_det45()
  111. {
  112.     register int *dP, *gP;
  113.     register int i, ix, iy, nx,index, ny;
  114.     register nxP1, nxM1, nyM1;
  115.  
  116.     nx = my_image->nx;    nxM1 = nx-1;    nxP1 = nx+1;
  117.     ny = my_image->ny;    nyM1 = ny-1;
  118.     
  119.     if((my_image->id45 = (int *)malloc(ny*nx*sizeof(int)))==0)
  120.     {
  121.         fprintf(stderr, "error: cannot allocate id45 array\n");
  122.         exit(1);
  123.     }
  124. /*
  125.  *    do top
  126.  *    then middle
  127.  *    then right side
  128. */
  129.     dP = my_image->id45+nx-2;
  130.     gP = my_image->gaussian+nx-2;
  131.     for(ix=nx-2; ix>-1; ix--)
  132.     {
  133. /*        d[ix] = g[ix] - g[ix+nx+1]; */
  134.         *dP = *gP - *(gP+nxP1);
  135.         dP--; gP--;
  136.     }
  137.     dP = my_image->id45;
  138.     gP = my_image->gaussian;
  139.     for(i=nx-2; i>-1; i--)
  140.     {
  141.         ix=i;
  142.         iy=1;
  143.         index = nx+ix;
  144.         while(ix>-1 && iy<nyM1)
  145.         {
  146. /*            dP[iy*nx+ix] = gP[(iy+1)*nx+ix-1]-gP[(iy-1)*nx+ix+1]; */
  147. /*            dP[iy*nx+ix] = gP[iy*nx+ix+nx-1] -gP[iy*nx+ix-nx+1];  */
  148.             dP[index] = gP[index+nxM1] - gP[index-nxM1];
  149.             index += nxM1;
  150.             ix--;
  151.             iy++;
  152.         }
  153.     }
  154.     for(i=1; i<ny; i++)
  155.     {
  156.         ix=nx-2;
  157.         iy=i;
  158.         index = iy*nx+ix;
  159.         while(ix>-1 && iy<nyM1)
  160.         {
  161. /*            dP[iy*nx+ix] = gP[(iy+1)*nx+ix-1]-gP[(iy-1)*nx+ix+1]; */
  162. /*            dP[iy*nx+ix] = gP[iy*nx+ix+nx-1] -gP[iy*nx+ix-nx+1];  */
  163.             dP[index] = gP[index+nxM1] - gP[index-nxM1];
  164.             index += nxM1;
  165.             ix--;
  166.             iy++;
  167.         }
  168.     }
  169.     dP = my_image->id45+nx+nx-1;
  170.     gP = my_image->gaussian+nx+nx-1;
  171.     for(iy=1; iy<ny; iy++)
  172.     {
  173. /*        d[iy*nx+nx-1] = g[iy*nx+nx-1] - g[(iy-1)*nx+nx-2]; */
  174. /*        d[iy*nx+nx-1] = g[iy*nx+nx-1] - g[iy*nx+nx-1-nx-1]; */
  175.         *dP = *gP - *(gP-nxP1);
  176.         dP+=nx; gP+=nx;
  177.     }
  178.     dP = my_image->id45+(ny-1)*nx;
  179.     gP = my_image->gaussian+(ny-1)*nx;
  180.     for(ix=0; ix<nxM1; ix++)
  181.     {
  182. /*        dP[(ny-1)*nx+ix] = gP[(ny-1)*nx+ix] - gP[(ny-2)*nx+ix+1];    */
  183. /*        dP[(ny-1)*nx+ix] = gP[(ny-1)*nx+ix] - gP[(ny-1)*nx+ix-nx+1]; */
  184.         *dP = *gP - *(gP-nxM1);
  185.         dP++; gP++;
  186.     }
  187.     dP = my_image->id45+(ny-1)*nx;
  188.     gP = my_image->gaussian+(ny-1)*nx;
  189. /*    dP[(ny-1)*nx+nx-1] = gP[(ny-1)*nx+nx-1] - gP[(ny-2)*nx+nx-2];      */
  190. /*    dP[(ny-1)*nx+nx-1] = gP[(ny-1)*nx+nx-1] - gP[(ny-1)*nx+nx-1-nx-1]; */
  191.     dP[nxM1] = gP[nxM1] - gP[-2];
  192.     dP = my_image->id45;
  193.     gP = my_image->gaussian;
  194.     dP[nxM1] = gP[nxM1]-gP[nx+nx-2];
  195. #ifdef DEBUG
  196.     image_Write_int("det45", my_image->id45);
  197. #endif
  198. }
  199.  
  200. void
  201. image_det135()
  202. {
  203.     register int *dP, *gP;
  204.     register int i, ix, iy, nx,index, ny;
  205.     register nxP1, nxM1, nyM1, nxM2;
  206.  
  207.     nx = my_image->nx;    nxM1 = nx-1;    nxP1 = nx+1;    nxM2 = nx-2;
  208.     ny = my_image->ny;    nyM1 = ny-1;
  209.     
  210.     if((my_image->id135 = (int *)malloc(ny*nx*sizeof(int)))==0)
  211.     {
  212.         fprintf(stderr, "error: cannot allocate id135 array\n");
  213.         exit(1);
  214.     }
  215. /*
  216.  *    do top
  217.  *    then middle
  218.  *    then right side
  219. */
  220.     dP = my_image->id135+1;
  221.     gP = my_image->gaussian+1;
  222.     for(ix=1; ix<nx; ix++)
  223.     {
  224. /*        d[ix] = g[ix] - g[ix+nx-1]; */
  225.         *dP = *gP - *(gP+nxM1);
  226.         dP++; gP++;
  227.     }
  228.     dP = my_image->id135;
  229.     gP = my_image->gaussian;
  230.     for(i=1; i<nxM1; i++)
  231.     {
  232.         ix=i;
  233.         iy=1;
  234.         index = nx+ix;
  235.         while(ix<nxM1 && iy<nyM1)
  236.         {
  237. /*            dP[iy*nx+ix] = gP[(iy+1)*nx+ix+1]-gP[(iy-1)*nx+ix-1];*/
  238. /*            dP[iy*nx+ix] = gP[iy*nx+ix+nx+1]-gP[iy*nx+ix-nx-1];  */
  239.             dP[index] = gP[index+nxP1] - gP[index-nxP1];
  240.             index += nxP1;
  241.             ix++;
  242.             iy++;
  243.         }
  244.     }
  245.     for(i=1; i<ny; i++)
  246.     {
  247.         ix=1;
  248.         iy=i;
  249.         index = iy*nx+ix;
  250.         while(ix<nxM1 && iy<nyM1)
  251.         {
  252. /*            dP[iy*nx+ix] = gP[(iy+1)*nx+ix+1]- gP[(iy-1)*nx+ix-1];*/
  253. /*            dP[iy*nx+ix] = gP[iy*nx+ix+nx+1] - gP[iy*nx+ix-nx-1]; */
  254.             dP[index] = gP[index+nxP1] - gP[index-nxP1];
  255.             index += nxP1;
  256.             ix++;
  257.             iy++;
  258.         }
  259.     }
  260.     dP = my_image->id135+nx;
  261.     gP = my_image->gaussian+nx;
  262.     for(iy=1; iy<ny; iy++)
  263.     {
  264. /*        d[iy*nx] = g[iy*nx] - g[(iy-1)*nx+2]; */
  265. /*        d[iy*nx] = g[iy*nx] - g[iy*nx-nx+2]; */
  266.         *dP = *gP - *(gP-nxM2);
  267.         dP+=nx; gP+=nx;
  268.     }
  269.     dP = my_image->id135+nx+nx-1;
  270.     gP = my_image->gaussian+nx+nx-1;
  271.     for(iy=1; iy<ny; iy++)
  272.     {
  273. /*        d[iy*nx+nx-1] = g[iy*nx+nx-1] - g[(iy-1)*nx+nx-2];  */
  274. /*        d[iy*nx+nx-1] = g[iy*nx+nx-1] - g[iy*nx+nx-1-nx-1]; */
  275.         *dP = *gP - *(gP-nxP1);
  276.         dP+=nx; gP+=nx;
  277.     }
  278.  
  279.     dP = my_image->id135+(ny-1)*nx+1;
  280.     gP = my_image->gaussian+(ny-1)*nx+1;
  281.     for(ix=1; ix<nxM1; ix++)
  282.     {
  283. /*        d[(ny-1)*nx+ix] = g[(ny-1)*nx+ix] - g[(ny-2)*nx+ix-1];    */
  284. /*        d[(ny-1)*nx+ix] = g[(ny-1)*nx+ix] - g[(ny-1)*nx+ix-nx-1]; */
  285.         *dP = *gP - *(gP-nxP1);
  286.         dP++; gP++;
  287.     }
  288.     dP = my_image->id135;
  289.     gP = my_image->gaussian;
  290.     dP[nxM1] = gP[nxM1] - gP[nx+nx-2];
  291.     dP[0] = gP[0] - gP[nx+1];
  292. #ifdef DEBUG
  293.     image_Write_int("det135", my_image->id135);
  294. #endif
  295. }
  296.